Solution Stack

The openDAQTM solution stack is built upon a robust set of features. With the aim of ensuring cross-platform compatibility to meet diverse customer requirements, the solution manifests into two distinct products

• openDAQ SDK

• openDAQTM LT

openDAQ SDK 

A software development kit that allows users to utilise the features from the solution stack in a most comfortable way on any operating system with the programming language you like.

openDAQ LT

A light-wise (LT) collection of straightforward C stacks, each representing a specific feature, designed for seamless integration into Real-Time Operating Systems.

Device discovery

The openDAQ facilitates effortless device discovery using mDNS (Multicast DNS) over IPv4 or IPv6 networks. This feature automatically detects all compatible openDAQ devices within your local network, simplifying their quick connection and configuration without requiring manual searching and entering of IP addresses. 

This is particularly beneficial in complex network environments or when using multiple openDAQ devices simultaneously, where manual device searching can be time-consuming. The auto-discovery function also supports advanced network settings, enables easy integration of devices into various systems, and ensures that all devices are always accurately and quickly detected. This capability is especially useful for users who want to focus on data collection and analysis, rather than the technical aspects of network setup.

Streaming

Reliable and high-performance streaming is a key feature of openDAQ. The streaming capability supports synchronous time-equidistant data and asynchronous data, accommodating a wide range of data types from simple scalar values to complex structure or matrix values.

Its reliability and performance is continuously staged in our compliance lab.

Currently, it is implemented with the web socket technology, which offers advantages such as sending streaming data into a web application and bypassing firewall restrictions on port blocking. However, it's worth noting that other physical layers can be added as needed.

On protocol level, openDAQ already implements different streaming protocol standards - openDAQ Streaming LT and openDAQ native streaming. openDAQ Streaming LT was developed and implemented to acquire reliable streaming data from limited devices where the openDAQ SDK can not be used. With openDAQ native streaming the most performant data transfer can be established between server and client application implemented with the openDAQ SDK.

Different streamable sampling types

openDAQ supports various sampling types to stream that cater to various data acquisition requirements. Supported types include:

• Synchronous sampling: This sampling type is crucial for applications requiring data points to be captured at precisely coordinated time intervals. This ensures accurate time alignment of data from multiple channels, essential for analysing time-dependent phenomena.

• Asynchronous sampling: This sampling type allows for the independent and uncoordinated collection of data points. It is beneficial in scenarios where data from different sources or sensors does not need to be time-synchronised.

• Single Value sampling: This sampling type enables the capture of individual data points at specific instances. This is particularly useful for applications that require data acquisition triggered by specific events or conditions, rather than continuous or time-based sampling.

Together, these sampling options make openDAQ an adaptable tool, capable of fitting various experimental setups and data collection methodologies, ensuring users can choose the most appropriate sampling strategy for their specific data acquisition needs.

Works with any data type

openDAQ is designed with a versatile data handling capability, supporting a wide array of data types to cater to diverse data acquisition needs. It efficiently processes:

• Scalar data: This data type is essential for capturing simple numerical values in various applications.

• Vector data: Enables the analysis of data sets with both direction and magnitude, which is crucial in fields like physics and engineering.

• Matrix data types: For more complex data arrangements, openDAQ's support for Matrix data types allows for sophisticated analysis involving multiple dimensions, ideal for advanced computational tasks.

• Binary data: For processing of raw, binary-encoded data from various sources.

This comprehensive support for different data types ensures that openDAQ can adapt to a multitude of data structures, making it a highly flexible solution for a wide range of data acquisition and analysis scenarios.

High data rates

The openDAQ SDK is specifically engineered to handle high data rates, making it an ideal solution for scenarios involving high-speed acquisition devices or systems with a high channel count. This feature ensures efficient data transfers, crucial for modern applications where large volumes of data are common.

Key aspects of this feature include:

• Optimised for High-Speed Data Acquisition: openDAQ is optimised to process and transfer data at high speeds, which is essential for applications like dynamic signal analysis, power analysis, high-frequency trading, or real-time monitoring in industrial settings.

• Efficient Handling of High Channel Counts: In scenarios where data is being captured from numerous sources simultaneously, openDAQ SDK efficiently manages the increased data throughput. This capability is particularly beneficial in complex acquisition systems, such as those used in aerospace, automotive testing, or large-scale industrial plants.

• Minimised Data Bottlenecks: The SDK's architecture is designed to minimise bottlenecks in data transfer, ensuring that the flow of data from the acquisition hardware to the storage or analysis tools is smooth and uninterrupted.

• Enhanced Data Integrity: Despite the high data rates, the integrity and accuracy of the data are maintained, ensuring that the quality of the information is not compromised.

• Flexible Integration with Various Devices: The SDK's ability to handle high data rates makes it compatible with a wide range of high-speed data acquisition devices, offering flexibility in system design and implementation.

By providing efficient data transfers at high data rates, the openDAQ SDK addresses the needs of demanding applications that require rapid data collection and processing, making it a robust tool for advanced data acquisition and analysis.

Configuration

openDAQ facilitates devices, smart sensors, or server parameters to autonomously and dynamically describe themselves — a process known as self-introspection. 

For this metadata is appended to these dynamically self-describing parameters. This metadata includes information such as the currently configurable values of a parameter, how a device alters a manipulation request, or their default value. Additionally, optional metadata such as unit or range is also available.

This capability enables clients to access and manipulate server parameters through a general purpose implemented Application Programming Interface (API). Consequently, software products can develop robust and feature-rich graphical user interfaces.

The openDAQ SDK configuration is based on OPC-UA technology, which utilises Ethernet TCP/IP. openDAQ extends the OPC-UA object model specification by adding an additional definition for DAQ devices, which is currently not available as a companion specification but rather as a vendor model from openDAQ.

openDAQ LT has no configuration support yet.

Open source

openDAQ is an open-source solution, licensed under the Apache 2.0 licence. This licensing choice reflects a commitment to open development and broad accessibility. Under the Apache 2.0, users and developers are granted considerable freedom with openDAQ.

Key aspects of this include:

• Free Use and Distribution: Users are free to use and distribute the openDAQTM software solutions, both in its original form or with modifications, without worrying about licensing fees or royalties.

• Source Code Access: The open-source nature means that its source code is readily available, allowing users to inspect, modify, and enhance the software according to their specific needs.

• Flexibility for Modifications: The Apache 2.0 licence permits modifications and derivative works, enabling developers to customise and extend openDAQTM to suit their particular applications and projects.

• No Copyleft Restrictions: Unlike some other open-source licences, the Apache 2.0 licence is permissive and doesn’t require derivative works to be distributed under the same licence terms. This offers greater flexibility for commercial use and integration into proprietary software.

• Protection Against Patent Risks: The licence provides an explicit grant of patent rights from contributors to users, protecting users from patent litigation risks associated with the use or distribution of the software.

• Minimal Requirements: The Apache 2.0 licence has minimal requirements regarding the distribution of modified software, making it less burdensome for users and developers to comply with its terms.

The open-source nature and the specific choice of the Apache 2.0 licence make openDAQ a highly accessible and flexible tool for a wide range of data acquisition and processing applications, fostering an inclusive and collaborative development community.

Synchronization

This feature is particularly crucial in systems where data from different sources need to be precisely synchronized in time to ensure accuracy and consistency in measurement and analysis. openDAQ includes built-in support for setting up synchronization topologies in the simplest manner possible. Regardless of the synchronization interface your device supports, openDAQ allows you to define your synchronization inputs and outputs if your device can share its timing with other devices.

Synchronization interfaces could be:

• Precision Time Protocol (PTP) 

• EtherCAT

• Internal CLK

• Inter Range Instrumentation Group (IRIG)

• Network Time Protocol (NTP)

• …

Whereas, Precision Time Protocol (PTP), plays a key role in openDAQ since it achieves high precision time alignment across multiple devices. PTP allows devices connected over a network to synchronize their clocks with an accuracy in the sub-microsecond range, making it an ideal solution for applications that demand high temporal precision, such as industrial automation, telecommunications, and networked measurement systems.

Utilizing PTP, openDAQ ensures that all connected devices in a network maintain a uniform time reference, effectively eliminating the time discrepancies that can occur in distributed systems. This synchronization is vital for correlating data recorded by different devices, ensuring that time-stamped data is accurately aligned and reliable between openDAQ certified devices.

Versatility

openDAQ is extremely versatile, making it an ideal solution for a wide range of data acquisition and control devices. It is ready to handle various types of inputs and devices, including:

• Analog I/O devices

• Digital I/O devices

• Smart sensors

• Cameras

• CAN bus and XCP devices

• Lidar devices

• GNSS and Inertial Navigation Systems

Embracing standards

openDAQ is committed to embracing and integrating a range of established industry standards, ensuring high interoperability and ease of integration in various technological ecosystems. This commitment to standards includes support for:

• mDNS (Multicast DNS),

• OPC-UA (Open Platform Communications Unified Architecture),

• PTP synchronization (Precision Time Protocol),

and more to come, each offering its unique advantages and makes easy system integration simple.

Cross-platform

The aim of openDAQ is to be truly cross-platform capable. This means ensuring seamless operation across a diverse range of operating systems and processor systems. 

Whereas the openDAQ SDK is fully compatible with major desktop operating systems, including Windows, Linux, and MacOS, providing a consistent and reliable experience regardless of the user's preferred OS. This broad compatibility ensures that the openDAQ SDK can be integrated into a wide array of computing environments, from personal computers to complex industrial systems.

In addition to desktop OS compatibility,  openDAQ SDK extends its support to mobile operating systems such as iOS and Android. This mobile compatibility opens up possibilities for portable, on-the-go data acquisition and analysis, making openDAQ SDK an ideal choice for applications that require mobility and flexibility.

openDAQ  LT completes the picture, as with the help of LT, core openDAQ features running on microcontroller systems for RTOS are also made available.

The cross-platform nature of openDAQ not only enhances its accessibility to a wider user base but also ensures that it can adapt to evolving technological landscapes and user needs. Whether it's for laboratory research, industrial monitoring, or mobile data analysis, openDAQ's cross-platform capability ensures that it remains a robust and adaptable solution for any kind of DAQ product - from smart sensors to DAQ analytics software.

Programming language independent

The openDAQ SDK distinguishes itself with its language-agnostic nature, rendering it a highly versatile solution suitable for various development environments. While the openDAQ SDK is primarily developed in C++ and utilises the Component Object Model (COM) design pattern, it offers dedicated language bindings for Python, C#, and Delphi.

This flexibility ensures that developers can seamlessly integrate and utilise the openDAQ SDK within their current systems and workflows, irrespective of their preferred programming language.

Multi-threaded design

The openDAQ SDK is built with performance in mind. It features a robust multi-threaded design, engineered specifically to handle intense data processing demands. This architecture allows openDAQ SDK to efficiently manage and process large volumes of data by distributing the workload across multiple threads and CPUs. As a result, data acquisition, processing, and analysis tasks are executed concurrently, leading to significant improvements in performance and responsiveness.

The multi-threaded design particularly shines in environments where high-speed data collection and soft real-time analysis are critical. It enables the system to handle simultaneous data streams without compromising on processing speed or data integrity. This approach not only maximizes the utilization of the system's processing capabilities but also ensures a smoother and more efficient handling of complex data sets.

Moreover, this design reduces the likelihood of bottlenecks in data processing, ensuring that openDAQ SDK can deliver consistent performance even under heavy data loads. Whether it's for high-frequency trading, real-time monitoring of industrial processes, or complex scientific research, openDAQ's multi-threaded architecture is adept at meeting the challenges of intensive data processing tasks.

Processing distribution

The openDAQ platform features an innovative Processing Distribution capability, where the same modules can operate both on the device firmware and within the application software. This unique approach offers several key advantages for data acquisition and processing:

• Consistent Functionality Across Systems: By running identical modules on the device firmware and the application software, openDAQ ensures consistent functionality and performance, regardless of where the processing takes place. This uniformity is crucial for systems requiring parallel processing both at the device level and in the software environment.

• Flexibility in Data Processing: Users have the flexibility to choose where the data processing occurs – either directly on the device or on the application software. This adaptability allows for optimal resource utilization and processing efficiency based on the specific requirements of the application.

• Seamless Integration and Compatibility: The ability to run the same modules in different environments simplifies integration, ensuring seamless compatibility between the device firmware and application software. This reduces complexities typically associated with configuring and maintaining such systems.

• Enhanced Performance and Efficiency: Distributing processing tasks between the device and the application software can lead to more efficient data handling, especially in scenarios with high data throughput or in systems with limited processing power at the device level.

• Simplified Development and Maintenance: For developers, having a unified set of modules that work across different layers of the system simplifies the development and maintenance process. It allows for a more streamlined approach to updates and enhancements, as changes made to the module will be reflected both on the device and the software.

Overall, the Processing Distribution feature of openDAQ provides a versatile and efficient solution for data acquisition systems, offering improved performance, consistency, and ease of use.